我使用gemini提取出了老师视频中展示的文档，非常好。因为老师确实没有给文档，blog里面也搜不到，幸好有了AI，帮我很大的忙。

配置安装 Setup

1. Install NodeJS and Database 前提是要安装nodejs和某种数据库，因为prisma通常是为关系型数据库构建的，所以NoSQL这些大部分都不能支持，只支持MongoDB。我按照老师的要求，安装了postgresql。

2. npm init -y ，初始化项目。 npm i --save-dev prisma typescript ts-node @types/node nodemon ， Install dependencies

3. Create tsconfig.json

   xxxxxxxxxx
   9
   1
   {
   2
     "compilerOptions": {
   3
       "sourceMap": true,
   4
       "outDir": "dist",
   5
       "strict": true,
   6
       "lib": ["esnext"],
   7
       "esModuleInterop": true
   8
     }
   9
   }
   

   这个是配置typescript相关的。

4. npx prisma init --datasource-provider postgresql ， Initial Prisma project

5. Connect Database

   a. Install VSCode extension for Prisma

   b. Also talk about auto formatting and npx prisma format

   xxxxxxxxxx
   13
   1
   // schema.prisma
   2
   datasource db {
   3
     provider = "postgresql"
   4
     url      = env("DATABASE_URL")
   5
   }
   6
   ​
   7
   generator client {
   8
     provider = "prisma-client-js"
   9
     output   = "../generated/prisma"
   10
   }
   11
   ​
   12
   // .env
   13
   DATABASE_URL="postgresql://postgres:password@localhost:5433/test"
   

   这里需要重点讲解一下，datasource db指的是Prisma orm该怎么样连接到数据库管理系统，provider指的是数据库管理系统的类型，可以是mysql、sqlite等等，url指的是连接数据库管理系统的哪一个数据库。

   在步骤4执行之后，会生成schema.prisma文件和.env文件，在.env文件里面，有一个DATABASE_URL的变量，这里存放的是数据库的地址。这个地址可以是本地数据库的地址，也可以是云服务器中数据库的地址。

   

   generator的作用是定义代码生成规则，provider指定用哪一个生成器，output自定义生成文件的输出目录。因为prisma的核心是“基于schema自动生成代码”，而generator就是“告诉prisma”要生成什么，怎么生成，生成到哪里“的关键配置。

   只有这样配置了，在代码中才能使用PrismaClient，来方便的操作数据库。

   url的格式是：postgresql://用户名:密码@主机:端口/数据库名，我的本地用户名默认是postgres，密码是123456，主机是localhost，端口是5432，数据库需要新建，打开powershell，输入psql -h localhost -p 5432 -U postgres，输入密码123456，然后输入create database prisma，这样就生成了一个名称为prisma的数据库。

   那么这里的url就写成这样DATABASE_URL="postgresql://postgres:123456@localhost:5432/prisma?schema=public"，这里的?schema=public，它的意思是告诉 Prisma（或其他工具）：默认使用 public 这个 schema 来查找表和执行查询。这涉及到postgresql的表结构，和MySQL是不一样的，先不用管。

   

   

6. Create User Schema with name

   xxxxxxxxxx
   4
   1
   model User {
   2
     id   Int    @id @default(autoincrement())
   3
     name String
   4
   }
   

7. npx prisma migrate dev --name init ， Create/Run migration。这一步是为了将定义的model迁移到数据库中去，dev表示只在开发环境做这件事，--name init表示为这次操作设置名称，方便以后查看。 这一步执行之后，会在prisma文件夹里面生成一个migrations文件夹，里面就是迁移文件，这些文件将与postgresql交互并进行用户指定的修改。 与此同时，也对Prisma client进行了更新，这样使用prisma client的时候，就能够用到最新的数据库。

8. npm install @prisma/client - Install Client (Talk about how this also generates the client as well for us and how this generation happens every time you migrate as well and how you can create this generation your self with npx prisma generate)

    

   创建一个script.ts文件，就可以写代码了。

   xxxxxxxxxx
   15
   1
   import { PrismaClient } from '@prisma/client'
   2
   ​
   3
   const prisma = new PrismaClient({ log: ["query"] })
   4
   ​
   5
   async function main() {
   6
     // ... you will write your Prisma Client queries here
   7
   }
   8
   ​
   9
   main()
   10
     .catch((e) => {
   11
       console.error(e.message)
   12
     })
   13
     .finally(async () => {
   14
       await prisma.$disconnect()
   15
     })
   

9. await prisma.user.create({ data: { name: "Sally" } }) - Create new user

10. await prisma.user.findMany() - Get all users

Schema

Data Sources

1. Can only have one datasource in your database
2. The provider represents what database to use
3. The url represents the URL of the database
4. Should store the URL in .env to avoid exposing database secrets and to make it easy to change from dev to production

Generators

1. Must have at least one generator but can have more than one

2. The provider represents what generator to use

   a. This can be any NPM library such as a GraphQL generator

Models

1. Models represent all the information about your database such as tables, columns, enums, etc.
2. Each model is represented by a number of fields

Fields

1. Fields are composed of a name, type, and optional type modifiers and attributes

FieldTypes

1. String
2. Boolean
3. Int
4. BigInt
5. Float-能不用就不用，基本被Decimal取代了
6. Decimal
7. DateTime-使用类型转换来指定具体类型

你想要的 PostgreSQL 类型	Prisma 写法（强烈推荐）	说明（精度 / 时区）	推荐指数
timestamp with time zone（最推荐）	DateTime @db.Timestamptz	保存 UTC 时间，带时区无关，精度 6 位（微秒）	5 stars
timestamp without time zone	DateTime @db.Timestamp	保存本地时间，不带时区，容易踩坑	2 stars
timestamptz（简写，同第 1 种）	DateTime（不写任何 @db 也行）	Prisma 默认就是 timestamptz！	5 stars
date（只存日期，不带时间）	DateTime @db.Date	相当于 2025-12-05，不带时间和时区	4 stars
time（只存时间，不带日期）	DateTime @db.Time	13:14:15，精度到微秒	3 stars
timetz（带时区的时间）	DateTime @db.TimeTz	很少用	1 star

xxxxxxxxxx
12
1
model User {
2
id        String   @id @default(cuid())
3
​
4
createdAt DateTime @default(now())         // 自动就是 timestamptz
5
updatedAt DateTime @updatedAt              // 自动就是 timestamptz
6
​
7
birthday  DateTime @db.Date               // 只存年月日，比如 1998-08-08
8
lastLogin DateTime?                        // 可空，带时区的时间戳
9
​
10
// 如果你真的想明确写出来（可读性更好）
11
loginAt   DateTime @db.Timestamptz
12
}

8. Json-如果使用的是postgresql，那么prisma会自动设置为JSONB类型
9. Bytes-存储文件哈希、加密 token、二进制小数据
10. Reference to another table (Post)

基本语法：

xxxxxxxxxx
1
1
@relation(name?: String, fields?: String[], references?: String[], onDelete?: ReferentialAction, onUpdate?: ReferentialAction, map?: String)

最重要的三个参数：

参数	类型	必填？	放在哪一边？	说明与取值
name	String（字符串字面量）	选填（但强烈建议写上）	两边都要写（且相同）	关系名字，用于消除歧义；迁移时保持关系稳定；精准include/select。
fields	String[]（字段名数组）	必须（有外键的一方）	外键所在的一方（多的一方）	指明本模型里哪个字段是外键
references	String[]（字段名数组）	必须（有外键的一方）	外键所在的一方	指向对端模型的哪个字段（通常是 @id 或 @@id）

这里的name可以用于精准include/select，这种需求在项目中是很常见的：

在多对多关系中，指定name参数，prisma会用这个name为我们创建一个中间表。

多对多关系的 @relation 指令不需要显式地定义 fields 和 references 参数。

xxxxxxxxxx
11
1
model Student {
2
id       Int       @id @default(autoincrement())
3
name     String
4
courses  Course[]  @relation("Enrollment")
5
}
6
​
7
model Course {
8
id       Int       @id @default(autoincrement())
9
title    String
10
students Student[] @relation("Enrollment")
11
}

解释：

• @relation("Enrollment") 中的 name 是 "Enrollment"。这意味着 Prisma 会为 Student 和 Course 之间的多对多关系创建一个中间表，名称会是 Enrollment。
• 通过使用 name，我们可以明确中间表的名称，而不依赖 Prisma 默认的命名规则。

查询：

xxxxxxxxxx
5
1
  const students = await prisma.student.findMany({
2
    include: {
3
      courses: true,  // 通过 include 加载关联的课程
4
    },
5
  })

---

xxxxxxxxxx
25
1
model User {
2
  id            String   @id @default(cuid())
3
​
4
  // 我写的文章（一对多）
5
  authoredPosts Post[]   @relation("AuthoredPosts")
6
​
7
  // 我点赞的文章（隐式多对多）← 两边 name 完全一样
8
  likedPosts    Post[]   @relation("UserLikedPosts")
9
​
10
  createdAt     DateTime @default(now())
11
}
12
​
13
model Post {
14
  id        String   @id @default(cuid())
15
  title     String
16
​
17
  // 作者（一对多）
18
  authorId  String
19
  author    User     @relation("AuthoredPosts", fields: [authorId], references: [id])
20
​
21
  // 被谁点赞（隐式多对多）← 两边 name 完全一样，不能写 fields/references
22
  likedBy   User[]   @relation("UserLikedPosts")
23
​
24
  @@index([authorId])
25
}

xxxxxxxxxx
18
1
const user = await prisma.user.findUnique({
2
  where: { id: "clxxxxxx" },           // 必须加 where！
3
  include: {
4
    authoredPosts: true,   // 我写的
5
    likedPosts:    true,   // 我点的赞
6
  },
7
})
8
​
9
// 或者分开查
10
const written = await prisma.user.findUnique({
11
  where: { id },
12
  select: { authoredPosts: { take: 10 } }
13
})
14
​
15
const liked = await prisma.user.findUnique({
16
  where: { id },
17
  select: { likedPosts: { take: 20 } }
18
})

如果两个关系都没写 name，include 里只能写 posts，要么全拿，要么全不拿，完全无法分开。

一、什么时候可以不写 @relation？（最常见的情况）

xxxxxxxxxx
10
1
model User {
2
id    String @id @default(cuid())
3
posts Post[]       // 这一边啥也不写
4
}
5
​
6
model Post {
7
id       String @id @default(cuid())
8
author   User   @relation(fields: [authorId], references: [id])
9
authorId String
10
}

结论：只要关系是「有外键的一方」写了 fields 和 references，另一方（User）可以完全不写 @relation，Prisma 自动推断，100% 正常工作。 这是目前 90% 项目都在用的最简写法。

二、什么时候必须写 @relation？（4 种硬性场景）

场景	必须写 @relation 的原因	正确写法示例
1. 自关联（同一个表里关联自己）	不写会报错 “Ambiguous relation”	见例子1
2. 一对多双向，但两边外键字段名不一致	Prisma 无法自动匹配	见例子2
3. 一个模型被多个关系引用（多对一多条）	Prisma 不知道 Post[] 对应哪条关系	见例子3
4. 多对多显式关系（中间表）		必须写 name 来配对

三、四大场景详细写法

场景1：自关联（粉丝、关注、上下级、树形评论）

xxxxxxxxxx
13
1
model User {
2
    id             String  @id @default(cuid()
3
​
4
    // 我关注的（我 → 对方）
5
    following      User[]  @relation("FollowRelation", fields: [followingId], references: [id])
6
    followingId    String?
7
​
8
    // 关注我的（对方 → 我）
9
    followers      User[]  @relation("FollowRelation")
10
​
11
    // 推荐：加索引
12
    @@index([followingId])
13
}

关键：两边都用同一个名字 "FollowRelation"，不然会报错。

场景2：外键字段名不是默认的 authorId

xxxxxxxxxx
11
1
model Post {
2
    id          String @id @default(cuid())
3
    title       String
4
    creator     User   @relation(fields: [createdById], references: [id])
5
    createdById String    // ← 不是 authorId！
6
}
7
​
8
model User {
9
    id    String @id @default(cuid())
10
    posts Post[] @relation("CreatedPosts")  // 必须写 name，否则找不到
11
}

场景3：一个模型被多个关系引用（最容易踩坑！）

xxxxxxxxxx
15
1
model User {
2
    id            String  @id @default(cuid())
3
​
4
    writtenPosts  Post[]  @relation("Author")     // 我写的文章
5
    likedPosts    Post[]  @relation("Likes")      // 我点赞的文章
6
}
7
​
8
model Post {
9
    id         String @id @default(cuid())
10
​
11
    author     User   @relation("Author", fields: [authorId], references: [id])
12
    authorId   String
13
​
14
    likedBy     User[] @relation("Likes")
15
}

不写 name 的话 Prisma 会报：Error: Ambiguous relation on model User.posts

场景4：显式多对多（中间表自己控制）

xxxxxxxxxx
17
1
model User {
2
    id         String         @id @default(cuid())
3
    followedBy Follow[]       // 我被谁关注
4
    following  Follow[]       // 我关注了谁
5
}
6
​
7
model Follow {
8
    followerId   String
9
    followingId  String
10
​
11
    follower     User   @relation("Following", fields: [followerId], references: [id])
12
    following    User   @relation("FollowedBy", fields: [followingId], references: [id])
13
​
14
    followedAt   DateTime @default(now())
15
​
16
    @@id([followerId, followingId])   // 复合主键
17
}

Field Type Modifiers

符号就下面两个，另外还有两个方法。

1. []

   a. Turns the column into a list. When used on a reference type it creates all needed foreign keys and such

   b. Can only be used on scalar types if the DB supports it

2. ?

   a. Makes a field optional

   b. Cannot be used with []

Field Attributes

1. Attributes have two levels

   a. Field attributes apply to one field @

   b. Block attributes apply to the entire block @@

2. @id

   a. All tables must have an id field or have a unique field

   b. Can be combined with @default

   i. autoincrement()-这个在postgresql里面就是serial类型了。

   ii. uuid()

   iii. cuid()-prisma推荐使用的id，就用这个

3. @@id

   a. Used to create composite ids @@id([FirstName, LastName])

4. @default

   a. Can be passed a static value or a function such as now()

5. @unique - Makes a field unique

6. @@unique - Makes a combination of fields unique @@unique(authorId, postId)

7. @@index - Create index on one or more fields @@index(authorId, postId)

8. @updatedAt - Automatically sets a field to the current time when you update the row

9. @relation

   a. The fields with relation types are not actually in the db

   b. One To Many

   xxxxxxxxxx
   10
   1
   model User {
   2
     id    Int    @id @default(autoincrement())
   3
     posts Post[]
   4
   }
   5
   ​
   6
   model Post {
   7
     id       Int    @id @default(autoincrement())
   8
     author   User   @relation(fields: [authorId], references: [id])
   9
     authorId Int
   10
   }
   

   c. One To One

   xxxxxxxxxx
   10
   1
   model User {
   2
     id      Int      @id @default(autoincrement())
   3
     profile Profile?
   4
   }
   5
   ​
   6
   model Profile {
   7
     id     Int  @id @default(autoincrement())
   8
     user   User @relation(fields: [userId], references: [id])
   9
     userId Int  @unique
   10
   }
   

   d. Many To Many

   xxxxxxxxxx
   9
   1
   model Post {
   2
     id         Int        @id @default(autoincrement())
   3
     categories Category[]
   4
   }
   5
   ​
   6
   model Category {
   7
     id    Int    @id @default(autoincrement())
   8
     posts Post[]
   9
   }
   

   e. The @relation field must take a field and references value.

   i. The field points to the field on the current model

   ii. The references points to the field on the other model the field value references

   f. If you have multiple relations on the same model you need to pass a name to the references attribute to disambiguate them

   xxxxxxxxxx
   13
   1
   model User {
   2
     id            Int     @id @default(autoincrement())
   3
     writtenPosts  Post[]  @relation("WrittenPosts")
   4
     favoritePosts Post[]  @relation("FavoritePosts")
   5
   }
   6
   ​
   7
   model Post {
   8
     id            Int     @id @default(autoincrement())
   9
     author        User    @relation("WrittenPosts", fields: [authorId], references: [id])
   10
     authorId      Int
   11
     favoritedBy   User?   @relation("FavoritePosts", fields: [favoritedById], references: [id])
   12
     favoritedById Int?
   13
   }
   

完全列表（官方所有字段属性，一共就这些）

举例说明：

Enums

如果使用的是postgresql，推荐使用postgresql原生enums，就是在postgresql数据库里面定义enums。然后在model定义的时候使用即可。

不推荐使用prisma的方式来定义enums，就是在schema.prisma里面不要定义enums。可以搜一下为什么，这里给一个理由：给已有枚举加一个新状态 → Prisma Migrate 直接 drop + recreate 整个 enum 类型，后果就是依赖这个 enum 的所有表都要重建 → 几千万行的大表锁表 40 分钟～3 小时，业务直接宕机。

而在postgresql原生里面进行修改，几乎没有什么影响，这是实际经验教训。

xxxxxxxxxx
9
1
model User {
2
  id   Int    @id @default(autoincrement())
3
  role Role   @default(BASIC)
4
}
5
​
6
enum Role {
7
  BASIC
8
  ADMIN
9
}

Possible Finished Schema

xxxxxxxxxx
57
1
// This is your Prisma schema file,
2
// learn more about it in the docs: https://pris.ly/d/prisma-schema
3
​
4
generator client {
5
  provider = "prisma-client-js"
6
}
7
​
8
datasource db {
9
  provider = "sqlite"
10
  url      = env("DATABASE_URL")
11
}
12
​
13
model User {
14
  id               String    @id @default(uuid())
15
  isAdmin          Boolean   @default(false)
16
  age              Int
17
  name             String
18
  email            String    @unique
19
  writtenPosts     Post[]    @relation("WrittenPosts")
20
  favoritePosts    Post[]    @relation("FavoritePosts")
21
  preferences      UserPreference? @relation(fields: [userPreferenceId], references: [id])
22
  role             Role      @default(BASIC)
23
  userPreferenceId String?   @unique
24
​
25
  @@unique([name, age])
26
  @@index([email])
27
}
28
​
29
model UserPreference {
30
  id            String   @id @default(uuid())
31
  emailUpdates  Boolean
32
  user          User?
33
}
34
​
35
model Post {
36
  id            String    @id @default(uuid())
37
  title         String
38
  averageRating Float     // Also talk about BigInt, Decimal, Json, Unsupported, an
39
  createdAt     DateTime  @default(now())
40
  updatedAt     DateTime  @updatedAt
41
  author        User      @relation("WrittenPosts", fields: [authorId], references: [id])
42
  authorId      String
43
  favoritedBy   User?     @relation("FavoritePosts", fields: [favoritedById], references: [id])
44
  favoritedById String?
45
  categories    Category[]
46
}
47
​
48
model Category {
49
  id     String  @id @default(uuid())
50
  name   String  @unique
51
  posts  Post[]
52
}
53
​
54
enum Role {
55
  BASIC
56
  ADMIN
57
}

Client

1. Automatically connects when you run the first query
2. Automatically disconnects when process ends
3. Manages connection pool so only ever need one instance of the client

先记住下面最简单的操作，复杂操作查询文档即可，不要连最简单的操作都记不住。

Create

1. create

   xxxxxxxxxx
   7
   1
   const user = await prisma.user.create({
   2
     data: {
   3
       email: 'kyle@test.com',
   4
       name: 'Kyle',
   5
       age: 27
   6
     }
   7
   })
   

   一对一、多对一新增使用connect来关联。

   xxxxxxxxxx
   11
   1
   // Create a new Post record and connect it to an existing User record.创建新post，同时将这个post关联到user.
   2
   // 注意，connect后面跟的只能是标了 @unique 或参与了 @@unique / @@id / @id 的字段，不一定只能是主键。
   3
   ​
   4
   const user = await prisma.post.create({
   5
     data: {
   6
       title: 'Hello World',
   7
       author: {
   8
         connect: { email: 'alice@prisma.io' },
   9
       },
   10
     },
   11
   });
   

2. createMany

   x
   1
   const user = await prisma.user.createMany({
   2
     data: [
   3
       {
   4
         email: 'sally@test.com',
   5
         name: 'Sally',
   6
         age: 25
   7
       },
   8
       {
   9
         email: 'john@test.com',
   10
         name: 'John',
   11
         age: 12
   12
       }
   13
     ],
   14
     skipDuplicates: true, // @unique 字段会校验是否唯一
   15
   })
   

Read

就记住这三个，不要嫌少，用的最多的就是这三种方法。

1. findUnique - Can also include/select

   按 id、@unique 字段或 @@unique / @@id 组合查一条记录；

   x
   1
   24
   1
   // 1. 按主键查
   2
   prisma.user.findUnique({ where: { id: userId } })
   3
   ​
   4
   // 2. 按任意 @unique 字段查（超好用！）
   5
   prisma.user.findUnique({ where: { email } })                    // email @unique
   6
   prisma.user.findUnique({ where: { phone: "13800138000" } })
   7
   prisma.user.findUnique({ where: { slug: "alice" } })
   8
   ​
   9
   // 3. 复合唯一索引（多租户必备），schema里面是这样定义的 @@unique([tenantId, email], name: "tenant_email")
   10
   prisma.user.findUnique({
   11
     where: { tenantId_email: { tenantId: "t1", email: "test@163.com" } }
   12
   })
   13
   ​
   14
   // 4. 复合主键（如果你的表是 @@id([a, b])）
   15
   prisma.order.findUnique({
   16
     where: { tenantId_orderNo: { tenantId: "t1", orderNo: "20250001" } }
   17
   })
   

2. findFirst - Same as findMany but only gets first result

   条件不是 schema 中的唯一键（例如多字段组合但没加 @@unique，或复杂过滤）；

   xxxxxxxxxx
   4
   1
   prisma.post.findFirst({
   2
     where: { published: true, author: { email: { contains: "gmail" } } },
   3
     orderBy: { createdAt: 'desc' },
   4
   })
   

3. findMany - Can also select/include

   a. distinct - Can do distinct queries

   b. take / skip - Can do pagination

   c. orderBy - Can do sorting

   x
   1
   const results = await prisma.post.findMany({
   2
     where: {
   3
       title: { contains: 'Prisma' },
   4
     },
   5
     orderBy: { id: 'asc' },
   6
   })
   

Basic Filtering 基本过滤条件

where条件：

xxxxxxxxxx
76
1
// 2.2 where 条件全家福（标量 + 数组 + JSONB + 关系）
2
prisma.post.findMany({
3
  where: {
4
    // 数值比较运算符（全部支持）
5
    viewCount: { 
6
      gt: 1000,        // 大于 1000
7
      gte: 1000,       // 大于等于
8
      lt: 10000,       // 小于
9
      lte: 10000,      // 小于等于
10
      equals: 5000,    // 等于（可以省略，直接写 viewCount: 5000 也行）
11
      not: 0,          // 不等于
12
    },
13
​
14
    // 字符串操作（底层走 PostgreSQL ILIKE / LIKE）
15
    title: { 
16
      contains: "Prisma",     // 包含「Prisma」
17
      mode: "insensitive"       // 不区分大小写（默认就是 insensitive，写出来更明确）
18
    },
19
    title: { startsWith: "2025" },   // 以「2025」开头
20
    title: { endsWith: ".md" },      // 以「.md」结尾
21
    title: { in: ["置顶", "精华"] },  // IN 数组
22
    title: { notIn: ["广告"] },
23
​
24
    // 数组字段（String[] / Int[] 等）
25
    tags: { 
26
      has: "TypeScript",          // 数组里包含某个值
27
      hasEvery: ["JS", "TS"],     // 必须同时包含这几个
28
      hasSome: ["Vue", "React"],  // 包含其中任意一个即可
29
      isEmpty: true,              // 空数组
30
    },
31
​
32
    // JSONB 字段操作（超级实用）
33
    metadata: { 
34
      equals: { plan: "pro" },                 // 完全相等
35
      path: ["plan"], equals: "pro"            // metadata->>'plan' = 'pro'
36
      path: ["settings", "theme"], equals: "dark", // 嵌套路径
37
      string_contains: "vip",                  // JSON 字符串里包含 vip
38
      string_starts_with: "gold",              // 以 gold 开头
39
      string_ends_with: "member",
40
    },
41
​
42
    // 关系存在性查询（神技！不需要 join）
43
    author: { 
44
      is: { isVip: true } ,         // 作者是 VIP
45
      isNot: { status: "banned" },  // 作者不是被封禁的
46
    },
47
    comments: { 
48
      some: { content: { contains: "赞" } },   // 至少有一条评论含「赞」
49
      none: { authorId: userId },              // 这篇文章没人评论过（我没评论）
50
      every: { content: { not: { contains: "差评" } } }, // 所有评论都不含差评
51
    },
52
    likedBy: { some: { id: userId } },   // 我点过赞的文章
53
​
54
    // 逻辑组合
55
    AND: [
56
      { published: true },
57
      { createdAt: { gte: new Date("2025-01-01") } },
58
    ],
59
    OR: [
60
      { title: { contains: "Prisma" } },
61
      { content: { contains: "ORM" } },
62
    ],
63
    NOT: { status: "deleted" },
64
  },
65
​
66
  // 排序（支持多字段）
67
  orderBy: [
68
    { viewCount: 'desc' },   // 阅读量倒序
69
    { createdAt: 'asc' },      // 时间正序（同分再按时间）
70
  ],
71
​
72
  // 分页方式推荐（游标分页 > offset）
73
  take: 20,
74
  skip: 0,
75
  // cursor: { id: "last_seen_id" },   // 游标分页示例
76
});

include/select方式：

52
1
// 2.3 include vs select 详细注释版
2
prisma.user.findUnique({
3
  where: { id: userId },
4
​
5
  // include 方式：全部字段 + 关联（简单粗暴，适合快速开发）
6
  include: {
7
    posts: {
8
      where: { published: true },
9
      orderBy: { createdAt: 'desc' },
10
      take: 10,
11
      include: {
12
        tags: true,                                      // 标签全量
13
        _count: { select: { comments: true, likedBy: true } }, // 评论数、点赞数
14
      },
15
    },
16
    profile: true,                                       // 一对一 profile 全量
17
    _count: {                                            // 统计关联数量
18
      select: {
19
        posts: true,        // 文章总数
20
        likedPosts: true,     // 点过赞的文章数
21
      },
22
    },
23
  },
24
​
25
  // select 方式：精准控制字段（生产环境强烈推荐！性能更好）
26
  select: {
27
    id: true,
28
    email: true,
29
    name: true,
30
    createdAt: true,
31
​
32
    posts: {
33
      select: {
34
        id: true,
35
        title: true,
36
        createdAt: true,
37
        _count: { select: { comments: true } },
38
      },
39
      where: { published: true },
40
      orderBy: { createdAt: 'desc' },
41
      take: 5,
42
    },
43
​
44
    profile: {
45
      select: { bio: true },
46
    },
47
​
48
    _count: {
49
      select: { posts: true, likedPosts: true },
50
    },
51
  },
52
});

聚合、统计、分组：

xxxxxxxxxx
29
1
// 2.4 聚合、统计、分组（2025 年最常用写法）
2
const result = await prisma.post.aggregate({
3
  where: { authorId: userId },
4
  _count: { id: true },           // 文章总数
5
  _avg:   { viewCount: true },    // 平均阅读量
6
  _sum:   { viewCount: true },    // 总阅读总量
7
  _min:   { viewCount: true },
8
  _max:   { viewCount: true },
9
});
10
​
11
const group = await prisma.post.groupBy({
12
  by: ['authorId'],               // 按作者分组
13
  _count: { id: true },           // 每人文章数
14
  _avg:   { viewCount: true },
15
  having: {
16
    id: { _count: { gt: 5 } },    // 只返回文章数 >5 的作者
17
  },
18
  orderBy: { _count: { id: 'desc' } },
19
});
20
​
21
const count = await prisma.post.count({
22
  where: {
23
    published: true,
24
    AND: [
25
      { createdAt: { gte: new Date("2025-01-01") } },
26
      { createdAt: { lte: new Date("2025-12-31") } },
27
    ],
28
  },
29
});

Relation Filtering 关联过滤

简单案例：

x
1
const result = await prisma.user.findMany({
2
  where: {
3
    post: {
4
      every: {
5
        published: true
6
      },
7
      some: {
8
        content: {
9
          contains: "Prisma"
10
        }
11
      }
12
    }
13
  }
14
})

xxxxxxxxxx
63
1
prisma.post.findMany({
2
  where: {
3
    // 1. some：关联记录中「至少有一条」满足条件（最常用！）
4
    comments: {
5
      some: {
6
        content: { contains: "厉害" },           // 有评论说“厉害”
7
        // OR: [{ author: { isVip: true } }, { content: { contains: "1000+" } }]
8
      },
9
    },
10
​
11
    likedBy: {
12
      some: { id: currentUserId },               // 我点过赞的文章
13
    },
14
​
15
    tags: {
16
      some: { name: { in: ["TypeScript", "Prisma"] } }, // 至少有一个标签是 TS 或 Prisma
17
    },
18
​
19
    // 2. every：关联记录「全部」都要满足条件（常用于审核/权限）
20
    comments: {
21
      every: {
22
        status: "approved",                      // 所有评论都已通过审核（没有一条待审或拒绝）
23
      },
24
    },
25
​
26
    // 3. none：关联记录「一条都不」满足条件 = 完全没有（神技！）
27
    comments: {
28
      none: { authorId: currentUserId },         // 我一条评论都没发过
29
    },
30
​
31
    likedBy: {
32
      none: { id: currentUserId },               // 我没点过赞（可用于“显示点赞按钮”）
33
    },
34
​
35
    reports: {
36
      none: { status: "pending" },               // 这篇文章没有任何待处理的举报 → 可以正常展示
37
    },
38
​
39
    // 4. is：对端记录「本身」满足条件（一对多/一对一常用）
40
    author: {
41
      is: {
42
        isVip: true,                             // 作者是 VIP
43
        status: "active",                        // 作者状态正常
44
        // AND: [{ isVip: true }, { createdAt: { gte: new Date("2025-01-01") } }],
45
      },
46
    },
47
​
48
    profile: {
49
      is: { bio: { not: null } },                // 一对一：用户填了 bio
50
    },
51
​
52
    // 5. isNot：对端记录「本身」不满足条件
53
    author: {
54
      isNot: {
55
        status: "banned",                        // 作者没被封号
56
        // OR: [{ status: "deleted" }, { isVip: false }]
57
      },
58
    },
59
  },
60
  // 下面这些可以随便混着用
61
  orderBy: { createdAt: 'desc' },
62
  take: 20,
63
});

Update

总体原则是先使用where条件，然后使用data更新值。

1. update - Can also include/select

   a. Only updates 1 record

   b. Must include data and where

   ①基础更新（单表）

   xxxxxxxxxx
   14
   1
   // 普通字段更新
   2
   await prisma.user.update({
   3
     where: { id: userId },                    // 任何唯一约束都行
   4
     data: {
   5
       name: "新名字",
   6
       avatar: "https://xxx.jpg",
   7
       status: "active",
   8
       score: { increment: 10 },               // +10
   9
       viewCount: { decrement: 1 },            // -1
   10
       roles: { set: ["user", "admin"] },      // 完全替换数组
   11
       roles: { push: "moderator" },           // 追加一个
   12
       metadata: { set: { plan: "pro" } },     // JSON 整体替换
   13
     },
   14
   });
   

   ②一对多：修改文章标题 + 同时关联/取消关联作者

   xxxxxxxxxx
   17
   1
   await prisma.post.update({
   2
     where: { id: postId },
   3
     data: {
   4
       title: "2025 年 Prisma 还是香",
   5
       content: "更新了内容",
   6
   ​
   7
       // 更换作者（connect）
   8
       author: { connect: { email: "new@author.com" } },
   9
   ​
   10
       // 解除作者关系（disconnect）
   11
       // author: { disconnect: true },
   12
   ​
   13
       // 置为 null（如果外键可空）
   14
       // author: { disconnect: true },
   15
       // authorId: null,
   16
     },
   17
   });
   

   ③更复杂的操作：多对多、upsert方法，用的时候查询即可。

Number Operations

数字操作，感觉不实用。

1. increment

2. decrement

3. multiply

4. divide

   xxxxxxxxxx
   8
   1
   const updatedUser = await prisma.post.update({
   2
     where: { "name": "Kyle" },
   3
     data: {
   4
       age: {
   5
         increment: 1
   6
       }
   7
     }
   8
   })
   

Delete

1. delete - Can also select/include

   a. Only deletes 1 record

   x
   1
   await prisma.post.delete({
   2
     where: { id: postId },                    // 任何唯一约束都行
   3
   });
   

2. deleteMany - Can also select/include

   a. Only deletes 1 record

   x
   1
   await prisma.post.deleteMany({
   2
     where: {
   3
       authorId: userId,
   4
       createdAt: { lt: new Date("2023-01-01") }, // 删除用户 2023 年前的文章
   5
     },
   6
   });
   

收集资料

以 @ 或 @@ 开头属性

Prisma 中所有以 @ 或 @@ 开头的东西都叫 Attributes（属性），可以作用于：

• 字段（Field-level attributes） → 用 @
• 模型（Model-level attributes） → 用 @@

下面给你一个 最完整、最清晰、业务开发最常用的列表。（已按用途分类，不用背，查表即可）

一、字段级属性（Field Attributes）——以 @ 开头

用于 字段（column）级别 的功能，比如主键、默认值、映射等。

1. 主键 & 唯一性

2. 默认值 / 自动更新

3. 关系（Relation）

例：

xxxxxxxxxx
1
1
author User @relation(fields: [authorId], references: [id])

4. 映射（Mapping）

5. 类型转换（原生数据库类型）

二、模型级属性（Model Attributes）——以 @@ 开头

用于 模型（表）级别 的功能，比如复合索引、表名映射等。

6. 表级映射（Mapping）

7. 索引（Index）

8. 复合主键

注意：复合主键不能和 @id 共存。

9. 关系名称（Relation Names）

一般用于双向关系中的自引用模型：

xxxxxxxxxx
2
1
parent  Comment? @relation("CommentReplies")
2
replies Comment[] @relation("CommentReplies")

虽然写在 @relation 里，但属于模型关系配置范畴。

完整总结表（最常用）

字段级（@）

模型级（@@）